System.Collections.Generic.HashSet<T> class
This article provides supplementary remarks to the reference documentation for this API.
The HashSet<T> class provides high-performance set operations. A set is a collection that contains no duplicate elements, and whose elements are in no particular order.
The capacity of a HashSet<T> object is the number of elements that the object can hold. A HashSet<T> object's capacity automatically increases as elements are added to the object.
The HashSet<T> class is based on the model of mathematical sets and provides high-performance set operations similar to accessing the keys of the Dictionary<TKey,TValue> or Hashtable collections. In simple terms, the HashSet<T> class can be thought of as a Dictionary<TKey,TValue> collection without values.
A HashSet<T> collection is not sorted and cannot contain duplicate elements. If order or element duplication is more important than performance for your application, consider using the List<T> class together with the Sort method.
HashSet<T> provides many mathematical set operations, such as set addition (unions) and set subtraction. The following table lists the provided HashSet<T> operations and their mathematical equivalents.
HashSet operation | Mathematical equivalent |
---|---|
UnionWith | Union or set addition |
IntersectWith | Intersection |
ExceptWith | Set subtraction |
SymmetricExceptWith | Symmetric difference |
In addition to the listed set operations, the HashSet<T> class also provides methods for determining set equality, overlap of sets, and whether a set is a subset or superset of another set.
.NET Framework only: For very large HashSet<T> objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled
attribute of the <gcAllowVeryLargeObjects>
configuration element to true
in the run-time environment.
The HashSet<T> class implements the ISet<T> interface.
HashSet and LINQ set operations
LINQ provides access to the Distinct
, Union
, Intersect
, and Except
set operations on any data source that implements the IEnumerable or IQueryable interfaces. HashSet<T> provides a larger and more robust collection of set operations. For example, HashSet<T> provides comparisons such as IsSubsetOf and IsSupersetOf.
The primary difference between LINQ set operations and HashSet<T> operations is that LINQ set operations always return a new IEnumerable<T> collection, whereas the HashSet<T> equivalent methods modify the current collection.
Typically, if you must create a new set or if your application needs access only to the provided set operations, using LINQ set operations on any IEnumerable<T> collection or array will be sufficient. However, if your application requires access to additional set operations, or if it is not desirable or necessary to create a new collection, use the HashSet<T> class.
The following table shows the HashSet<T> operations and their equivalent LINQ set operations.
HashSet operation | LINQ equivalent |
---|---|
UnionWith | Union |
IntersectWith | Intersect |
ExceptWith | Except |
Not provided. | Distinct |
SymmetricExceptWith | Not provided. |
Overlaps | Not provided. |
IsSubsetOf | Not provided. |
IsProperSubsetOf | Not provided. |
IsSupersetOf | Not provided. |
IsProperSupersetOf | Not provided. |
SetEquals | Not provided. |